function parsePropertyName() {

    if (tokType === _num || tokType === _string) return parseExprAtom();

    return parseIdent(true);

  }

  // Parse a function declaration or literal (depending on the

  // `isStatement` parameter).

  function parseFunction(node, isStatement) {

    if (tokType === _name) node.id = parseIdent();

    else if (isStatement) unexpected();

    else node.id = null;

    node.params = [];

    var first = true;

    expect(_parenL);

    while (!eat(_parenR)) {

      if (!first) expect(_comma); else first = false;

      node.params.push(parseIdent());

    }

    // Start a new scope with regard to labels and the `inFunction`

    // flag (restore them to their old value afterwards).

    var oldInFunc = inFunction, oldLabels = labels;

    inFunction = true; labels = [];

    node.body = parseBlock(true);

    inFunction = oldInFunc; labels = oldLabels;

    // If this is a strict mode function, verify that argument names

    // are not repeated, and it does not try to bind the words `eval`

    // or `arguments`.

    if (strict || node.body.body.length && isUseStrict(node.body.body[0])) {

      for (var i = node.id ? -1 : 0; i < node.params.length; ++i) {

        var id = i < 0 ? node.id : node.params[i];

        if (isStrictReservedWord(id.name) || isStrictBadIdWord(id.name))

          raise(id.start, "Defining '" + id.name + "' in strict mode");

        if (i >= 0) for (var j = 0; j < i; ++j) if (id.name === node.params[j].name)

          raise(id.start, "Argument name clash in strict mode");

      }

    }

    return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");

  }

  // Parses a comma-separated list of expressions, and returns them as

  // an array. `close` is the token type that ends the list, and

  // `allowEmpty` can be turned on to allow subsequent commas with

  // nothing in between them to be parsed as `null` (which is needed

  // for array literals).

  function parseExprList(close, allowTrailingComma, allowEmpty) {

    var elts = [], first = true;

    while (!eat(close)) {

      if (!first) {

        expect(_comma);

        if (allowTrailingComma && options.allowTrailingCommas && eat(close)) break;

      } else first = false;

      if (allowEmpty && tokType === _comma) elts.push(null);

      else elts.push(parseExpression(true));

    }

    return elts;

  }

  // Parse the next token as an identifier. If `liberal` is true (used

  // when parsing properties), it will also convert keywords into

  // identifiers.

  function parseIdent(liberal) {

    var node = startNode();

    node.name = tokType === _name ? tokVal : (liberal && !options.forbidReserved && tokType.keyword) || unexpected();

    tokRegexpAllowed = false;

    next();

    return finishNode(node, "Identifier");

  }

});